1 C 语言基础：

📜 原文

📖 逐步解释

∑ 公式拆解

💡 数值示例

⚠️ 易错点

📝 总结

🎯 存在目的

🧠 直觉心智模型

💭 直观想象

1C 语言基础：

2自定义类型、指针、函数

COMS W3157
Borowski 博士

3编码风格

对于系统编程，大多数人使用 Linux 内核的风格

https://www.kernel.org/doc/Documentation/process/coding-styl e.rst

对于 C 语言编程，请参阅 1TBS (1 True Brace Style，K&R 的一个小变体)：

https://en.wikipedia.org/wiki/Indentation style

还有许多其他选项可用
可能取决于偏好、您正在贡献的项目、您工作的公司等。
确保...
您的代码可读
您保持一致性
您的代码在您使用的编辑器中看起来都一样

4C 关键字

| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |

有关更多信息，请参阅 https://www.geeksforgeeks.org/keywords-in-c/。

5C 运算符优先级

| 优先级 | | 运算符 | 描述 | 结合性 |

| :--- | :--- | :--- | :--- | :--- |

| | 1 | ++ --
()
[]
.
->
(type)\{list\} | 后缀增量和减量
函数调用
数组下标
结构体和联合体成员访问
通过指针访问结构体和联合体成员
复合字面量 (C99) | 从左到右 |

| | 2 | ++ --
+ -
! ~
(type)
*
&
sizeof
Alignof | 前缀增量和减量 ${ }^{[\text {注 1] }}$
一元加和减
逻辑非和位非
类型转换
间接寻址 (解引用)
取地址
大小 (sizeof) ${ }^{[\text {注 2] }}$
对齐要求 (C11) | 从右到左 |

6C 运算符优先级

| 3 | * / % | 乘法、除法和取余 | 从左到右 |

| :--- | :--- | :--- | :--- |

| 4 | + - | 加法和减法 | |

| 5 | <<>> | 位左移和位右移 | |

| 6 | < <=
> >= | 关系运算符 < 和 $\leq$
关系运算符 > 和 $\geq$ | |

| 7 | == != | 关系运算符 = 和 $\neq$ | |

| 8 | & | 按位与 | |

| 9 | ^ | 按位异或（独占或） | |

| 10 | | | 按位或（包含或） | |

| 11 | && | 逻辑与 | |

| 12 | || | 逻辑或 | |

7C 运算符优先级

| 13 | ?: | 三元条件运算符 ${ }^{[\text {注 3] }}$ | 从右到左 |

| :--- | :--- | :--- | :--- |

| $14^{[\text {注 4] }}$ | =
+= -=
*= /= %=
<<= >>=
&= ^= |= | 简单赋值
加法和减法赋值
乘法、除法和取余赋值
位左移和位右移赋值
按位与、异或和或赋值 | |

| 15 | , | 逗号 | 从左到右 |

有关更多详细信息，请参阅 https://en.cppreference.com/w/c/language/operator precedence.html。

8类型转换

在 C 语言中，类型转换是一种非常有用的工具，用于将值从一种数据类型更改为另一种数据类型。

我们为什么需要类型转换？

也许我们想要为某个值分配更多内存（例如：int -> double），或者在字母和数字之间切换（例如：char -> int）等。

有 2 种不同的类型转换方法：

隐式类型转换 - 当编译器在我们没有编写任何代码指令的情况下进行转换时。
显式类型转换 - 当我们明确告诉编译器进行类型转换时。

两种方法的示例将在下文介绍！

9隐式类型转换

10隐式类型转换

图表中向右的移动称为提升，向下的移动称为降级。
如果变量在新类型中可表示，则提升保证保留变量值。
降级可能导致溢出，并改变变量的值。

11隐式类型转换示例

```

int main(int argc, char **argv) {

char var1 = 0x41; // type cast: 0x41 -> 'A'; integer-> char

int var2 = 1.5; // type cast: 1.5 -> 1; float -> integer

// type cast: -1 -> Oxffffffff; signed -> unsigned

unsigned int var3 = -1;

}

```

char $\mathrm{c}=0 \times 41424344$ ; c 的值是多少？假设未启用 -Werror=overflow。

12隐式类型转换示例

```

int main(int argc, char **argv) {

char var1 = 0x41; // type cast: Ox41 -> 'A'; integer-> char

int var2 = 1.5; // type cast: 1.5 -> 1; float -> integer

// type cast: -1 -> Oxffffffff; signed -> unsigned

unsigned int var3 = -1;

}

```

char $\mathrm{c}=0 \times 41424344$ ;

c 的值是多少？ $16^{1} \times 4+16^{0} \times 4=68$ ，或 ' D ' 假设未启用 -Werror=overflow。

13显式类型转换示例

为了保证在 C 中将值转换为新类型，请使用类型转换运算符，其语法为 (new_type) value。

```

int main(int argc, char **argv) {

float f;

int a = 20, b = 3;

f = a/b; // f 是什么？ 6

f = (float)a/b; // f 现在是什么？ ~6.666667

```

}

14通过宏定义常量

宏通常用于定义永远不会改变且程序其余部分经常访问的值。

使用 \#define 定义

示例：\#define PI 3.14

预处理器在将源代码传递给编译器之前，将 $P /$ 的每个实例替换为 3.14。

```

#define PI 3.14

int main(int argc, char **argv) {

float pi = PI; // pi = 3.14

return 0;

}

```

15枚举

将多个常量组织在一起。
第一个成员的值为 0，下一个为 1，依此类推，除非明确指定。
示例
enum boolean \{NO, YES\}
定义 NO 为 0，YES 为 1
enum months \{JAN $=1$ , FEB, MAR, ... \}
enum escapes \{BELL $=$ '\a', BACKSPACE $=' \backslash \mathrm{~b} ', \ldots\}$

16枚举的使用

```

enum week { Sunday, Monday, Tuesday,

Wednesday, Thursday, Friday, Saturday };

int main(int argc, char **argv) {

enum week today;

today = Wednesday; // today = ?

return 0;

}

```

17枚举的使用

```

enum week { Sunday, Monday, Tuesday,

Wednesday, Thursday, Friday, Saturday };

int main(int argc, char **argv) {

enum week today;

today = Wednesday; // today = 3

return 0;

}

```

18结构体

结构体是不同类型的变量的集合，在单一类型下。

它类似于 C++/Java/Python 中的类。
C 中没有类。

```

struct my_struct {

int x;

int y;

int z;

};

```

19结构体的使用

```

struct book {

int year;

int month;

int book_id;

}; // 不要忘记这里的 ";"。

int main() {

struct book book1; // 声明 book1 为 Books 类型

book1.book_id = 100; // 访问结构体中的成员

return 0;

}

```

20联合体

联合体用于在同一内存位置存储不同类型的数据。

```

union my_union {

int i;

short s;

char c;

};

```

\underset{\text { int }}{\text { 整数 }} \text { (4 字节) }\left\{\begin{array}{c} \text { short } \\ \text { (2 字节) } \end{array}\right\}

联合体需要足够的空间来存储其最大的成员。但是，它只能容纳一个信息；对一个成员的赋值会影响其他成员。

my_union 的大小是多少？

21联合体的使用

```

union my_union { int i; short s; char c; };

int main(int argc, char **argv) {

union my_union test;

int var0;

test.i = 0;

test.c = 'A';

test.s = 16383;

varO = test.c;

}

```

22数组

数组是数据项的集合，所有数据项都具有相同的类型，并使用公共名称进行访问。
它可以是多维的。

```

在栈上分配的数组示例：

int a[10]; // type name[size1]

char b[10][100];

struct my_struct c[5][10][20];

```

23数组的使用

```

int main(int argc, char **argv) {

int array[10];

array[1] = 100;

array[2] = 200;

array[3] = array[1] + array[2];

array[0] = 1000; // 这是对的吗？

array[10] = 1000; // 这是对的吗？

}

```

24数组的使用

```

int main(int argc, char **argv) {

int array[10];

array[1] = 100;

array[2] = 200;

array[3] = array[1] + array[2];

array[0] = 1000; // 是的，数组是基于 0 的。

array[10] = 1000; // 不，有效索引是 0-9。

}

```

25数组初始化

数组可以按如下方式进行显式初始化：

```

int a[3];

a[O] = O; a[1] = 1; a[2] = 2;

// 0, 1, 2 分别赋值给 a[0], a[1], a[2]。

int a[3] = { 0, 1, 2 };

// 与 int a[3] = { 0, 1, 2 }; 相同，大小推断。

int a[] = { 0, 1, 2 };

// 与 int a[3] = { 1, 0, 0 }; 相同

int a[3] = { 1 };

// 将所有 100 个元素初始化为 0。

// 第一个元素显式为 0，其余隐式为 0。

int a[100] = { 0 };

```

26sizeof()

是一个看起来像函数的运算符。返回类型或变量的字节大小。

```

int x = 56;

// sizeof(x) 和 sizeof(int) 都返回 4

int a[3];

// sizeof(a) 返回 12 (3 乘以 sizeof(int))

```

27指针

（C 语言中最重要的概念之一）

28高级概述

内存就像一个长的字节数组。

| 72 | 101 | 108 | 108 | 111 | 32 | 65 | 80 | 33 |

| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |

| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |

指针存储一个字节（或字节块的开始）的索引，称为内存地址。

例如，值为 5 的指针将指向上面示例中的值 32。（细节要复杂一些，但这是基本思想。） UNIVERSITY

29高级概述

| 72 | 101 | 108 | 108 | 111 | 32 | 65 | 80 | 33 |

| ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |

| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |

如果我们有一个名为 p 的指针，它指向地址 5，我们可以：

读取地址 5 处的值 (val = *p)
更改值 ( ${ }^{\star} \mathrm{p}=$ new_val)
更改指针以指向不同的地址，而不改变指向的内存 ( $\mathrm{p}=\mathrm{p}+1$ )

30高级概述

理解指针的关键在于理解指针本身存储在内存中的某个位置，所以我们可以有一个指向指针的指针！

地址 3 指向地址 6，地址 6 指向地址 1。

31指针（实践中）

指针是数据对象，存储位于计算机内存中另一个数据对象的内存地址。
在 64 位计算机上，指针类型存储一个 unsigned long int 的内存地址，因此该类型的大小为 8 字节。
指针有两种主要操作：解引用运算符 (*) 和取地址运算符 (\&)。
指针声明示例（从右到左阅读）：

int intptr; // 指向一个整数 char charptr; // 指向一个字符 struct my_struct *structptr; // 指向一个结构体 int **intptrptr; // 指向一个整数指针

32指针的使用

| | 8 字节
" | | 4 字节 | 4 字节 | | 4 字节 | |

| :--- | :--- | :--- | :--- | :--- | :--- | :--- | :--- |

| | | | | | | | |

| | p | 999 | 1000 | 1004 | b | 1008 | C |

将计算机内存想象成一长排盒子，每个盒子容纳一个字节。每种类型的变量（如 int 或 char）都占用固定数量的这些盒子。
指针只是一个变量，它记住内存中另一个变量的地址（或位置）。
这使我们能够使用其内存位置查找和操作该变量。

33指针的使用

既然我们有一个指向 a 的指针，我们可以使用解引用运算符 (*) 访问和修改 a 的值。

这两行具有相同的效果。

\text { *p = 2; } \quad a=2 ;

*p 相当于说：“沿着粉色箭头，访问那里的值。”

34指针算术

COLUMBIA

35指针实现

C 中指针的一些更精细的细节：

在 C 语言中，数组索引运算符实际上是使用指针定义的。具体来说， $a[i]$ 被定义为 * (a $+i)$ 。由于 $a$ 只是指向数组开头的指针，添加 $i$ 只是从数组开头开始，递增 $i$ 个元素，并返回在该内存地址处找到的值。
int $i$ 与名为 var_type p 的指针之间的加法定义为 p + i 产生一个位于 p 之后 isizeof (var_type) 字节的内存地址。这使得上面的数组索引运算符能够按预期工作，无论数组类型如何！

36指针实现

C 中指针的一些更精细的细节：

与基本类型（如 char 和 int）不同，指针不能在类型之间进行隐式转换。因此，此代码段无法编译：

```

int *p;

double *x = p; // 编译器错误：不兼容的指针类型

Instead we should write double x = (double ) p.

```

C 包含一个 void * 类型，它可以隐式转换，但不能解引用。也就是说，此代码段无法编译：

```

void *p;

int x = p; // 编译器错误：无法解引用 void

```

37指针实现

C 中指针的一些更精细的细节：

C 在 stddef.h 中将 NULL 定义为 0。
解引用空指针会编译，但会导致运行时错误，因为内存地址 0 通常无法被 C 可执行文件访问。此代码段会导致段错误：

```

int *p = NULL;

int x = *p; // 运行时段错误

```

38定义您自己的类型

```

typedef ;

typedef unsigned int uint; typedef struct my_struct {

...

} my_struct;

typedef union my_union {

int i;

char c;

double d;

char data[sizeof(double)];

} my_union;

```

Typedefs 缩短了整个项目中的声明！

39定义您自己的类型

```

typedef struct book {

int year;

int month;

int book_id;

} book; // do not forget about the ";" here

int main() {

book book1; // struct Book Book1;

book1.book_id = 100;

return 0;

}

```

40变量作用域 - 局部

有三种变量作用域：局部、全局、静态。这些不同作用域级别告诉我们变量可以从何处访问。

局部：变量仅在函数内有效。
在函数使用前在函数内定义
由编译器在程序的栈上分配
在函数顶部定义（ANSI C 要求）

```

void func1() {

int i;

i = 1;

}

void func2() {

i = 1; // 无效作用域（我们不能从 func1 外部访问 'i'

// 除非重新声明它）

}

```

41变量作用域 - 全局

全局：整个程序都可以访问的变量。
在函数外部定义

```

int g_debug_level;

void func1() {

g_debug_level = 1;

}

void func2() {

g_debug_level = 2;

}

void func3() {

g_debug_level = 3;

}

```

42变量作用域 - 文件静态

静态 - 变量在退出其声明的先前作用域后仍保留其值。
静态变量有两种类型：
文件静态变量 - 与全局变量非常相似，只是不能在其定义文件之外访问。

```

static int g_debug_level; // 在 file1.c 中

void func1() { // 在 file1.c 中

g_debug_level = 1; // OK

}

void func2() { // 在 file2.c 中

g_debug_level = 2; // NOT OK

}

```

43变量作用域 - 块静态

块静态变量 - 其工作方式与文件静态变量相同，但它不可用于其定义的块之外的代码（非全局）

```

int static_integer() {

static int i = 100;

i++;

return i;

}

int main() {

for (int i = 0; i < 5; i++) {

printf("%d\n", static_integer());

}

```

44函数

声明函数很容易！

```

int my_func(char arg1, int arg2, float arg3);

// return_type, function_name(arguments list)

```

函数可见性：

函数可以在程序中的任何地方调用...
除非使用 static 关键字，它将可见性限制在定义它们的文件中，例如：

```

static int my_func(char arg1, int arg2, float arg3);

```

45参数传递 (1)

C 仅使用传值调用！

这意味着子函数所做的更改不会影响父函数。

```

int main() {

int i = 0;

callee(i);

printf("%d\n", i);

return 0;

}

```

void callee(int c) {

c = 10;

}

```

这个程序的输出是什么？

46参数传递 (1)

C 仅使用传值调用！

这意味着子函数所做的更改不会影响父函数。

```

int main() {

int i = 0;

callee(i);

printf("%d\n", i);

return 0;

}

```

void callee(int c) {

c = 10;

}

```

这个程序的输出是什么？ 0

47参数传递 (2)

我们还可以使用函数的返回值更新变量的值。

```

int main() {

int i = 0;

i = callee(i);

printf("%d\n", i);

return 0;

}

```

int callee(int c) {

c = 10;

return c;

}

```

这个程序的输出是什么？

48参数传递 (2)

我们还可以使用函数的返回值更新变量的值。

```

int main() {

int i = 0;

i = callee(i);

printf("%d\n", i);

return 0;

}

```

int callee(int c) {

c = 10;

return c;

}

```

这个程序的输出是什么？ 10

49参数传递 (3)

我们还可以使用指针更新变量的值。

```

int main() {

int i = 0;

callee(&i);

printf("%d\n", i);

return 0;

}

```

void callee(int *c) {

*c = 10; // 解引用

}

```

这个程序的输出是什么？

50参数传递 (3)

我们还可以使用指针更新变量的值。

```

int main() {

int i = 0;

callee(&i);

printf("%d\n", i);

return 0;

}

```

void callee(int *c) {

*c = 10; // 解引用

}

```

这个程序的输出是什么？ 10

51函数指针

正如我们可以有一个指向内存中其他位置数据的指针变量一样，我们也可以有一个函数指针，它存储函数的地址，允许函数作为参数传递并动态调用。

在本课程中，我们最常使用函数指针来实现多态性。

我们可能需要对整数、双精度浮点数或字符串（char *）的数组进行排序。
每种数据类型都需要不同的比较器函数，需要将其传递给 sort() 函数。

52函数指针示例

```

#include

int add(int a, int b) { return a + b; }

void say_hi() { puts("Hi"); }

int main() {

// 声明一个与 add() 函数签名匹配的函数指针。

int (*add_ptr) (int, int);

// 声明一个与 say_hi() 函数签名匹配的函数指针。

void (*say_hi_ptr) ();

// 赋值函数指针。

add_ptr = &add; say_hi_ptr = &say_hi;

// 通过它们的函数指针调用函数。

printf("%d", add_ptr(2, 3));

say_hi_ptr();

return 0;

}

```

53传递函数指针

```

/**

整数比较器。如果 a > b，返回 > 0；如果 a < b，返回 < 0；如果 a = b，返回 0。

int int_cmp(int a, int b) {

if (a > b) {

return 1;

}

if (a < b) {

return -1;

}

return 0;

}

int binary_search(const int key, const int *values,

const size_t num_elems, int (*cmp) (int, int)) {

...

int result = cmp(key, values[mid]);

}

int array[] = { 1, 4, 7, 18, 90 };

int retval = binary_search(4, array, 5, int_cmp);

```

📝 我的笔记

1C 语言基础：

2自定义类型、指针、函数

3编码风格

4C 关键字

5C 运算符优先级

6C 运算符优先级

7C 运算符优先级

8类型转换

9隐式类型转换

10隐式类型转换

11隐式类型转换示例

12隐式类型转换示例

13显式类型转换示例

14通过宏定义常量

15枚举

16枚举的使用

17枚举的使用

18结构体

19结构体的使用

20联合体

21联合体的使用

22数组

23数组的使用

24数组的使用

25数组初始化

26sizeof()

27指针

28高级概述

29高级概述

30高级概述

31指针（实践中）

32指针的使用

33指针的使用

34指针算术

35指针实现

36指针实现

37指针实现

38定义您自己的类型

39定义您自己的类型

40变量作用域 - 局部

41变量作用域 - 全局

42变量作用域 - 文件静态

43变量作用域 - 块静态

44函数

45参数传递 (1)

46参数传递 (1)

47参数传递 (2)

48参数传递 (2)

49参数传递 (3)

50参数传递 (3)

51函数指针

52函数指针示例

53传递函数指针